{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:09.226443Z",
     "start_time": "2025-03-10T13:15:05.332573Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=9, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.1\n",
      "numpy 2.0.1\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 准备数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:21.218154Z",
     "start_time": "2025-03-10T13:15:09.227442Z"
    }
   },
   "source": [
    "from tensorflow import keras\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words = vocab_size, index_from = index_from)"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:21.223836Z",
     "start_time": "2025-03-10T13:15:21.219163Z"
    }
   },
   "source": [
    "\n",
    "print(\"train\", len(train_data), train_labels.shape)  #25000个样本，每个样本是一段话，每个单词用一个数字表示\n",
    "print(\"test\", len(test_data), test_labels.shape)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 25000 (25000,)\n",
      "test 25000 (25000,)\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:21.298735Z",
     "start_time": "2025-03-10T13:15:21.224840Z"
    }
   },
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构造 word2idx 和 idx2word"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:21.336618Z",
     "start_time": "2025-03-10T13:15:21.300732Z"
    }
   },
   "source": [
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,     # 填充 token\n",
    "    \"[BOS]\": 1,     # begin of sentence\n",
    "    \"[UNK]\": 2,     # 未知 token\n",
    "    \"[EOS]\": 3,     # end of sentence\n",
    "})\n",
    "\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ],
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:22.762033Z",
     "start_time": "2025-03-10T13:15:21.337619Z"
    }
   },
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "for text in train_data:\n",
    "    length = len(text)\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "    \n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 6
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:22.774727Z",
     "start_time": "2025-03-10T13:15:22.763033Z"
    }
   },
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx\n",
    "        self.idx2word = idx2word\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx\n",
    "        self.bos_idx = bos_idx\n",
    "        self.eos_idx = eos_idx\n",
    "        self.unk_idx = unk_idx\n",
    "    \n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"如果padding_first == True，则padding加载前面，否则加载后面\"\"\"\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length-2]] + [self.eos_idx]\n",
    "            if padding_first:\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices #padding在前\n",
    "            else:\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)\n",
    "    \n",
    "    \n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "    \n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=True)\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "print(\"decode text\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   0,    0,    0,    1, 4825,  182,    3])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   0,    1,   14,    9,    6, 2181,    3])\n",
      "decode text\n",
      "[PAD] [PAD] [PAD] [BOS] hello world [EOS]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[PAD] [BOS] this is a test [EOS]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:22.779625Z",
     "start_time": "2025-03-10T13:15:22.775741Z"
    }
   },
   "source": [
    "# 看看训练集的数据\n",
    "\n",
    "tokenizer.decode(train_data[:2], remove_bos=False, remove_eos=False, remove_pad=False)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\",\n",
       " \"[BOS] big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal [UNK] the hair is big lots of boobs [UNK] men wear those cut [UNK] shirts that show off their [UNK] sickening that men actually wore them and the music is just [UNK] trash that plays over and over again in almost every scene there is trashy music boobs and [UNK] taking away bodies and the gym still doesn't close for [UNK] all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\"]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 8
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集与 DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:24.810253Z",
     "start_time": "2025-03-10T13:15:22.780625Z"
    }
   },
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    \n",
    "def collate_fct(batch):\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 这里使用 padding first\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "# 用RNN，缩短序列长度\n",
    "train_ds = IMDBDataset(train_data, train_labels, remain_length=False)\n",
    "test_ds = IMDBDataset(test_data, test_labels, remain_length=False)"
   ],
   "outputs": [],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:24.814627Z",
     "start_time": "2025-03-10T13:15:24.811254Z"
    }
   },
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ],
   "outputs": [],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "source": [
    "for text, label in train_dl: #检查样本是否存在问题\n",
    "    print(text.shape, label.shape)\n",
    "    break"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:24.841850Z",
     "start_time": "2025-03-10T13:15:24.815627Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 500]) torch.Size([128, 1])\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:24.852275Z",
     "start_time": "2025-03-10T13:15:24.842849Z"
    }
   },
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        super(LSTM, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=bidirectional)\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim)\n",
    "        self.fc = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # [bs, seq length]\n",
    "        x = self.embeding(x)\n",
    "        # [bs, seq length, embedding_dim] -> shape [bs, seq length，hidden_dim]\n",
    "        seq_output, (hidden, cell) = self.lstm(x)\n",
    "        # print(f'seq_output.shape{seq_output.shape}')\n",
    "        # print(f'hidden.shape{hidden.shape}') #最后一个时间步的输出\n",
    "        # print(f'cell.shape{cell.shape}') #最后一个时间步的cell state\n",
    "        # print(seq_output[:, -1, :].squeeze()==hidden.squeeze()) #squeeze() 去掉轴的尺寸为1的哪个轴\n",
    "        # print(seq_output[:, -1, :].squeeze()==cell.squeeze())\n",
    "        x = seq_output[:, -1, :]\n",
    "        # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "    \n",
    "sample_inputs = torch.randint(0, vocab_size, (2, 128))\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层单向 LSTM \"))       \n",
    "for key, value in LSTM().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 一层单向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "source": [
    "model = LSTM()\n",
    "#随机一个（128,500）的输入\n",
    "sample_inputs = torch.randint(0, vocab_size, (128, 500))\n",
    "sample_outputs = model(sample_inputs)\n",
    "print(sample_outputs.shape)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:24.971200Z",
     "start_time": "2025-03-10T13:15:24.853274Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 1])\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "source": [
    "64*64"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:24.977616Z",
     "start_time": "2025-03-10T13:15:24.973197Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "source": [
    "4 * 16 * 64 #lstm.weight_ih_l0"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:24.982816Z",
     "start_time": "2025-03-10T13:15:24.978615Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "source": [
    "128*64"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:24.988138Z",
     "start_time": "2025-03-10T13:15:24.983816Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8192"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": [
    "print(\"{:=^80}\".format(\" 一层双向 LSTM \"))\n",
    "for key, value in LSTM(bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:24.996978Z",
     "start_time": "2025-03-10T13:15:24.989137Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 一层双向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "       lstm.weight_ih_l0_reverse        paramerters num: 4096\n",
      "       lstm.weight_hh_l0_reverse        paramerters num: 16384\n",
      "        lstm.bias_ih_l0_reverse         paramerters num: 256\n",
      "        lstm.bias_hh_l0_reverse         paramerters num: 256\n",
      "              layer.weight              paramerters num: 8192\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "source": [
    "print(\"{:=^80}\".format(\" 两层单向 LSTM \"))\n",
    "for key, value in LSTM(num_layers=2).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:25.004697Z",
     "start_time": "2025-03-10T13:15:24.997978Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 两层单向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "           lstm.weight_ih_l1            paramerters num: 16384\n",
      "           lstm.weight_hh_l1            paramerters num: 16384\n",
      "            lstm.bias_ih_l1             paramerters num: 256\n",
      "            lstm.bias_hh_l1             paramerters num: 256\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:25.009964Z",
     "start_time": "2025-03-10T13:15:25.005698Z"
    }
   },
   "cell_type": "code",
   "source": "16*64*4 #4是4倍",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:25.016075Z",
     "start_time": "2025-03-10T13:15:25.010963Z"
    }
   },
   "cell_type": "code",
   "source": "64*64*4",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16384"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:25.452884Z",
     "start_time": "2025-03-10T13:15:25.017076Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 21
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:25.610170Z",
     "start_time": "2025-03-10T13:15:25.453884Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 22
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:25.615781Z",
     "start_time": "2025-03-10T13:15:25.611172Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 23
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:15:25.622898Z",
     "start_time": "2025-03-10T13:15:25.616782Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:21:18.363109Z",
     "start_time": "2025-03-10T13:15:25.623898Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 20\n",
    "\n",
    "model = LSTM()\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-lstm\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-lstm\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    test_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/3920 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "3168fbc8bd854ac1979c0b408f6aa4b6"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:21:18.696320Z",
     "start_time": "2025-03-10T13:21:18.364105Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 26
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-10T13:21:27.027344Z",
     "start_time": "2025-03-10T13:21:18.697317Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-lstm/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3584\n",
      "accuracy: 0.8641\n"
     ]
    }
   ],
   "execution_count": 27
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
